import * as antd from './antd';
import { fieldType } from './enum';

export { antd };

/**
 * 动态设置多层级属性值
 * @param _obj 需要设置的对象
 * @param field 字段名（例：field.options.rules.type）
 * @param val 值 （例：'string'）
 * @returns 设置好的对象（例：field: { options: rules: { type: 'string' } }）
 */
export const setVal = (_obj, field, val) => {
  const arr = field.split('.');
  const str = arr[0];
  let temp = _obj[str];
  if (temp === undefined) {
    _obj[str] = {};
    temp = _obj[str];
  }
  if (field.indexOf('.') !== -1) {
    for (let i = 1; i < arr.length; i++) {
      if (i === arr.length - 1) {
        temp[arr[i]] = val;
        break;
      }
      if (temp[arr[i]] === undefined) {
        temp[arr[i]] = {};
      }
      temp = temp[arr[i]];
    }
  } else {
    _obj[field] = val;
  }

  return _obj;
};

/**
 * 动态获取多层级属性值
 * @param _obj 需要获取的对象（例：field: { options: rules: { type: 'string' } }）
 * @param field 字段名（例：field.options.rules.type）
 * @returns 值 （例：'string'）
 */
export const getVal = (_obj, field) => {
  const arr = field.split('.');
  const str = arr[0];
  let temp = _obj[str];
  if (temp === undefined) {
    return undefined;
  }
  if (field.indexOf('.') !== -1) {
    for (let i = 1; i < arr.length; i++) {
      if (i === arr.length - 1) {
        return temp[arr[i]];
      }
      if (temp[arr[i]] === undefined) {
        return undefined;
      }
      temp = temp[arr[i]];
    }
  }
  return temp;
};

export interface FieldAttr {
  /**
   * 是否允许删除
   */
  allowDeleteFlag: number;
  /**
   * 附件数量
   */
  attachmentNumber: number;
  /**
   * 自动归档
   */
  autoArchiveFlag: number;
  /**
   * 归属业务Id，根据层级对应层级主键
   */
  belongBusinessId: string;
  /**
   * 日期格式
   */
  dateFormat: number;
  /**
   * 日期类型
   */
  dateType: number;
  /**
   * 小数点位数
   */
  decimalPoint: number;
  /**
   * 默认值
   */
  defaultValue: string;
  /**
   * 默认值类型
   */
  defaultValueType: number;
  /**
   * 字段属性
   */
  fieldAttr: number;
  /**
   * 业务层级
   */
  fieldBusinessLevel: number;
  /**
   * 字段编码，在不同分类下不得重复（删除无效）
   */
  fieldCode: string;
  /**
   * 字段主键
   */
  fieldId: string;
  /**
   * 字段名称，在不同分类下不得重复
   */
  fieldName: string;
  /**
   * 字段类型
   */
  fieldType: number;
  /**
   * 格式校验
   */
  formatCheck: number;
  /**
   * 栅格布局
   */
  gridLayoutNumber: number;
  /**
   * 分类主键
   */
  groupId: string;
  /**
   * 是否隐藏字段名称
   */
  hideFieldNameFlag: number;
  /**
   * 隐藏提示信息，鼠标悬浮时显示
   */
  hidePromptFlag: number;
  /**
   * 长度限制
   */
  lengthLimit: number;
  /**
   * 最多可循环次数
   */
  maxCycleNumber: number;
  /**
   * 最大值限制
   */
  maxValueLimit: number;
  /**
   * 最小值限制
   */
  minValueLimit: number;
  /**
   * 是否多选
   */
  multipleFlag: number;
  /**
   * 数值格式
   */
  numericFormat: number;
  /**
   * 选项列表
   */
  optionList: any;
  /**
   * 选项来源
   */
  optionSource: number;
  /**
   * 占位提示
   */
  placeholder: string;
  /**
   * 提示信息
   */
  promptInfo: string;
  /**
   * 是否只读
   */
  readonlyFlag: number;
  /**
   * 是否必填
   */
  requiredFlag: number;
  /**
   * 显示分隔线
   */
  showDividerFlag: number;
  /**
   * 模板任务Id
   */
  sopTaskId: string;
  /**
   * 源字段Id
   */
  sourceFieldId: string;
  /**
   * 任务Id
   */
  taskId: string;
  /**
   * 字段值
   */
  valueContext: string;
  /**
   * 是否可见
   */
  visibleFlag: number;
}

export const attrs = [
  {
    remote: 'allowDeleteFlag',
    local: 'options.allowDeleteFlag',
  },
  {
    remote: 'attachmentNumber',
    local: 'options.attachmentNumber',
  },
  {
    remote: 'autoArchiveFlag',
    local: 'options.autoArchiveFlag',
  },
  {
    remote: 'belongBusinessId',
    local: 'belongBusinessId',
  },
  {
    remote: 'dateFormat',
    local: 'options.dateFormat',
  },
  {
    remote: 'dateType',
    local: 'options.dateType',
  },
  {
    remote: 'decimalPoint',
    local: 'options.decimalPoint',
  },
  {
    remote: 'defaultVal',
    local: 'options.defaultVal',
  },
  {
    remote: 'defaultValueType',
    local: 'options.defaultValueType',
  },
  {
    remote: 'fieldAttr',
    local: 'options.attr',
  },
  {
    remote: 'fieldBusinessLevel',
    local: 'fieldBusinessLevel',
  },
  {
    remote: 'fieldCode',
    local: 'fieldCode',
  },
  {
    remote: 'fieldId',
    local: 'model',
  },
  {
    remote: 'frontId',
    local: 'key',
  },
  {
    remote: 'fieldName',
    local: 'fieldName',
  },
  {
    remote: 'fieldType',
    local: 'fieldType',
  },
  {
    remote: 'formatCheck',
    local: 'options.format',
  },
  {
    remote: 'gridLayoutNumber',
    local: 'options.gridLayoutNumber',
  },
  {
    remote: 'groupId',
    local: 'groupId',
  },
  {
    remote: 'hideFieldNameFlag',
    local: 'options.showLabel',
  },
  {
    remote: 'hidePromptFlag',
    local: 'options.hidePromptFlag',
  },
  {
    remote: 'lengthLimit',
    local: 'options.maxlength',
  },
  {
    remote: 'maxCycleNumber',
    local: 'options.maxCycleNumber',
  },
  {
    remote: 'maxValueLimit',
    local: 'options.max',
  },
  {
    remote: 'minValueLimit',
    local: 'options.min',
  },
  {
    remote: 'multipleFlag',
    local: 'options.multipleFlag',
  },
  {
    remote: 'remoteConfig',
    local: 'options.remoteConfig',
  },
  {
    remote: 'numericFormat',
    local: 'options.numericFormat',
  },
  {
    remote: 'optionList',
    local: 'options.options',
  },
  {
    remote: 'optionSource',
    local: 'options.remote',
  },
  {
    remote: 'placeholder',
    local: 'options.placeholder',
  },
  {
    remote: 'promptInfo',
    local: 'options.promptInfo',
  },
  {
    remote: 'readonlyFlag',
    local: 'options.readonlyFlag',
  },
  {
    remote: 'requiredFlag',
    local: 'options.rules.required',
  },
  {
    remote: 'showDividerFlag',
    local: 'options.showDivider',
  },
  {
    remote: 'sopTaskId',
    local: 'options.sopTaskId',
  },
  {
    remote: 'sourceFieldId',
    local: 'options.sourceFieldId',
  },
  {
    remote: 'taskId',
    local: 'options.taskId',
  },
  {
    remote: 'valueContextObj',
    local: 'options.valueContextObj',
  },
  {
    remote: 'visibleFlag',
    local: 'options.visibleFlag',
  },
  {
    remote: 'linkContent',
    local: 'options.linkContent',
  },
  {
    remote: 'multipleFlag',
    local: 'options.multipleFlag',
  },
];

export enum formatType {
  year = 1,
  month = 2,
  date = 3,
  date_hour = 4,
  date_hour_minute = 5,
  date_time = 6,
}

export const format = {
  1: [{ label: 'YYYY', value: 11 }],
  2: [
    { label: 'YYYYMM', value: 21 },
    { label: 'YYYY-MM', value: 22 },
    { label: 'YYYY/MM', value: 23 },
    { label: 'YYYY.MM', value: 24 },
  ],
  3: [
    { label: 'YYYYMMDD', value: 31 },
    { label: 'YYYY-MM-DD', value: 32 },
    { label: 'YYYY/MM/DD', value: 33 },
    { label: 'YYYY.MM.DD', value: 34 },
  ],
  4: [
    { label: 'YYYYMMDDHH', value: 41 },
    { label: 'YYYY-MM-DD HH', value: 42 },
    { label: 'YYYY/MM/DD HH', value: 43 },
    { label: 'YYYY.MM.DD HH', value: 44 },
  ],
  5: [
    { label: 'YYYYMMDDHHmm', value: 51 },
    { label: 'YYYY-MM-DD HH:mm', value: 52 },
    { label: 'YYYY/MM/DD HH:mm', value: 53 },
    { label: 'YYYY.MM.DD HH:mm', value: 54 },
  ],
  6: [
    { label: 'YYYYMMDDHHmmss', value: 61 },
    { label: 'YYYY-MM-DD HH:mm:ss', value: 62 },
    { label: 'YYYY/MM/DD HH:mm:ss', value: 63 },
    { label: 'YYYY.MM.DD HH:mm:ss', value: 64 },
  ],
};

/**
 * 获取日期组件的选择器类型
 * @param dateType 日期类型
 * @returns 选择器类型
 */
export const getDatePickerType = (dateType) => {
  if (dateType === formatType.year) {
    return 'year';
  } else if (dateType === formatType.month) {
    return 'month';
  }
  return 'date';
};

/**
 * 获取日期组件的日期格式对象
 * @param dateType 日期类型
 * @param dateFormat 日期格式值
 * @returns 日期格式对象
 */
export const getDatePickerFormat = (dateType, dateFormat) => {
  const formatObjArr = format[dateType];
  const formatObj = formatObjArr.find((e) => e.value === dateFormat);
  if (formatObj) {
    return formatObj;
  }
  return formatObjArr[0];
};

/**
 * 获取日期组件的时间选择功能
 * @param dateType 日期类型
 * @returns 时间选择功能
 */
export const getDatePickerShowTime = (dateType) => {
  if (dateType === formatType.date_hour) {
    return { format: 'HH' };
  } else if (dateType === formatType.date_hour_minute) {
    return { format: 'HH:mm' };
  } else if (dateType === formatType.date_time) {
    return { format: 'HH:mm:ss' };
  }
  return false;
};

// 是否json 字符串
export function isStringJSON(str: string): boolean {
  try {
    if (typeof JSON.parse(str) === 'object') {
      return true;
    }
    return false;
  } catch (e) {
    return false;
  }
}

/**
 * 转换字段值（展示用）
 * @param field 字段Obj
 * @returns 字段值
 */
export const convertFieldValueToShow = (field) => {
  const fieldValue = field.valueContextObj;
  if (!fieldValue) {
    if (
      [
        fieldType.upload,
        fieldType.checkbox,
        fieldType.cascader,
        fieldType.fixedCombination,
      ].includes(field.fieldType)
    ) {
      return [];
    } else if (field.fieldType === fieldType.select && field.multipleFlag) {
      return [];
    }
    return null;
  }
  if (
    [fieldType.singleLineText, fieldType.multiLineText].includes(
      field.fieldType
    ) &&
    fieldValue.stringVal
  ) {
    // 字符串
    return fieldValue.stringVal;
  } else if (field.fieldType === fieldType.number) {
    if (
      fieldValue.stringVal === undefined ||
      fieldValue.stringVal === null ||
      fieldValue.stringVal === ''
    ) {
      return null;
    }
    return Number(fieldValue.stringVal);
  } else if (field.fieldType === fieldType.radio && fieldValue.optionVal) {
    // 单选
    return fieldValue.optionVal.value;
  } else if (field.fieldType === fieldType.checkbox && fieldValue.optionsVal) {
    // 多选
    return fieldValue.optionsVal.map((temp) => temp.value);
  } else if (field.fieldType === fieldType.select) {
    // 下拉选择框返回obj（保证远端搜索时有名称可搜索）
    if (fieldValue.optionsVal) {
      const arr = fieldValue.optionsVal;
      if (field.multipleFlag) {
        return arr;
      }
      return arr.length > 0 ? arr[0] : null;
    } else if (field.multipleFlag) {
      return [];
    }
  } else if (field.fieldType === fieldType.dateTime && fieldValue.stringVal) {
    return fieldValue.stringVal;
  } else if (field.fieldType === fieldType.upload) {
    if (!fieldValue.fileUploadVal) {
      return [];
    }
    return fieldValue.fileUploadVal.map((item) => {
      return {
        uid: item.fileId,
        name: item.fileName,
        size: item.fileSize,
      };
    });
  } else if (field.fieldType === fieldType.cascader && fieldValue.optionsVal) {
    // 多选
    return fieldValue.optionsVal.map((temp) => temp.value);
  } else if (field.fieldType === fieldType.fixedCombination) {
    if (fieldValue.comboVal) {
      return fieldValue.comboVal;
    }
    return [];
  }
  return null;
};

/**
 * 转换从model中获取的字段值
 * @param valueObj 值对象
 * @param localField 前端字段Obj
 * @returns 值
 */
export const getValueByModel = (valueObj, localField) => {
  if (localField.fieldType === fieldType.select) {
    // 下拉选择的值作转换
    if (valueObj) {
      if (localField.options.multipleFlag) {
        // 多选
        return valueObj.map((temp) => temp.value);
      } else {
        return valueObj.value;
      }
    } else {
      if (localField.options.multipleFlag) {
        // 多选
        return [];
      } else {
        return null;
      }
    }
  }
  return valueObj;
};
